8.3.1.  Style stylingRules property

8.4.1.  StylingRule selector property

The selector (also sometimes called a filter), for the rule is defined as a predicate expression evaluating to either true or false.

Example — Example showcasing a Style made of StylingRules using CSCSS encoding

Landuse    // Selector for this first rule
{
   // Symbolizer properties to be set if this rule is selected
   visibility: false;
}

Roads    // Selector for this second rule
{
   // Symbolizer properties to be set if this rule is selected
   visibility: false;

   // Nested rule only considered if this parent rule is selected
   [viz.sd < 200000] // Selector for this nested rule
   {
      // Symbolizer properties to be set if this nested rule is selected
      visibility: true;
   }
}

8.4.2.  StylingRule nestedRules property

8.5.1.  Symbolizer visibility property

8.5.2.  Symbolizer opacity property

8.5.3.  Symbolizer zOrder property

8.6.1.  Parameter Values

The use of an expression as a Symbolizer property is called a Parameter Value, where an Expression can be substituted where a particular data type is expected, in which case the Expression will be resolved to that expected data type. Conceptually, all Symbolizer properties can be specified using any type of expression Parameter Value, but this is not required by this core conformance class, and specific requirements classes such as the “Symbolizer Parameter Value Expresssions” requirements class enable this behavior. Without a requirements class specifying otherwise, only Literal Expressions compatible with the expected data type are allowed as Parameter Values.

8.6.2.  Identifier Expressions

An Identifier Expression is represented by a textual property that gets resolved at runtime.

8.6.2.2.  System Identifiers

 

Figure 3 — System Identifiers UML Diagram

One specific type of identifier expressions use System Identifiers. A System Identifier refers to an internal state of the system, or a particular aspect of the data being portrayed.

The following System Identifiers are defined by this conformance class:

A capability System Identifier declares available capabilities of the rendering engine.

 

Figure 4 — Capability System Identifiers UML Diagram

Table 6 — System Identifier capabilities

Name	Definition	Data type and value
capabilities	Supported capabilities of the rendering engine	Capabilities
capabilities.vector	Support for Basic Vector Features Styling	Boolean (true if supported, false otherwise)
capabilities.coverage	Support for Basic Coverage Styling	Boolean (true if supported, false otherwise)
capabilities.labels	Support for Basic Labeling	Boolean (true if supported, false otherwise)
capabilities.hillshading	Support for Hill Shading	Boolean (true if supported, false otherwise)
capabilities.fontoutlines	Support for Font Outlines	Boolean (true if supported, false otherwise)
capabilities.hatches	Support for Hatch Fills	Boolean (true if supported, false otherwise)
capabilities.stipples	Support for Stipple Fills	Boolean (true if supported, false otherwise)
capabilities.dashes	Support for Dashed Strokes	Boolean (true if supported, false otherwise)
capabilities.casing	Support for Casing and Centerline	Boolean (true if supported, false otherwise)
capabilities.parametervalues	Support for Parameter Values	Boolean (true if supported, false otherwise)
capabilities.functions	Support for Function Expressions	Boolean (true if supported, false otherwise)
capabilities.math	Support for Math Functions	Boolean (true if supported, false otherwise)
capabilities.arrayrelations	Support for Array Relation Functions	Boolean (true if supported, false otherwise)
capabilities.textmanipulation	Support for Text Manipulation Functions	Boolean (true if supported, false otherwise)
capabilities.arithmetic	Support for Arithmetic Operators	Boolean (true if supported, false otherwise)
capabilities.textrelation	Support for Text Relation Operators	Boolean (true if supported, false otherwise)
capabilities.righthand	Support for Any right-hand operands	Boolean (true if supported, false otherwise)
capabilities.conditional	Support for Conditional Expressions	Boolean (true if supported, false otherwise)
capabilities.variables	Support for Variables	Boolean (true if supported, false otherwise)
capabilities.vendor.<vendorName>.<capability>	Support for a capability defined by a vendor extension	Boolean (true if supported, false otherwise)

Example 1 — CSCSS Example showcasing the use of a capability System Identifier with a fallback Styling Rule

 

{
   stroke: { color: gray, width: 1, opacity: 0.5 }; // Thinner translucent gray stroke fallback if we don't have dashes
   [capabilities.dashes]
   {
      stroke: { color: black, width: 2, dashPattern: [ 2,1 ], opacity: 1 };
   }
}

Table 7 — Visualization System Identifiers

Name	Definition	Data type and value
visualization	Current visualization state	Visualization
visualization.scaleDenominator	Current visualization scale denominator	float
visualization.dateTime	Current visualization date and time	DateTime
visualization.date	Current visualization date	Date
visualization.timeOfDay	Current visualization time of day	Time
visualization.timeInterval	Current visualization time of day	TimeInterval
visualization.pass	Current visualization rendering pass	int

Example 2 — CSCSS Example showcasing scale-dependent selector using system identifiers

 

Roads
{
   visibility: false;

   [viz.sd < 200000] // Roads will only be visible at scale 1:200,000 and closer
   {
      visibility: true;
   }
}

Visualization Rendering Passes

Setting up symbolization rules for a selector on a visualization pass allows to render all data of the map using different set of symbolizers. A later pass will only begin after all data layers and their features / coverage cells have been rendered with the symbolizers set for earlier visualization passes.

See also the feature pass introduced in Basic Vector Styling requirements class, which allows to render the same feature multiple times with different symbolizers before rendering the next feature.

Table 8 — Styles & Symbology Visual Ordering Constructs

Construct	Construct type	Data type	Behavior description
zOrder	Symbolizer property	float	In a single pass, modify default order of features / layers
visualization.pass	System identifier for selector	integer	Render all selected geometry features / coverage cells of data layers more than once with different symbolization, or after whole map drawn in previous pass
feature.pass	System identifier for selector	integer	Render feature geometry / coverage cell more than once potentially with different symbolization before rendering next data point.

Table 9 — Month enumeration

Name
january
february
march
april
may
june
july
august
september
october
november
december

Table 10 — Date class

Name	Definition	Data type and value	Multiplicity
year		int	1
month		Month	1
day		int	1

Table 11 — TimeOfDay class

Name	Definition	Data type and value	Multiplicity
hour		int	1
minutes		Month	1
seconds		int	1

Table 12 — Class TimeInstant

Name	Definition	Data type and value	Multiplicity
date		Date	1
time		TimeOfDay	1

Table 13 — TimeInterval class

Name	Definition	Data type	Multiplicity
start	start of the interval	TimeInstant	1
end	end of the interval	TimeInstant	1

Example 3 — CSCSS Example showcasing visualization time-dependent selector using system identifiers

 

Landuse
{
   visibility: false;

   // Landuse will only be visible when visualization date is later than January 1, 2020
   [viz.date > DATE('2020-01-01')]
   {
      visibility: true;
   }
}

Table 14 — Layer System Identifiers

Name	Definition	Data type and value
dataLayer.identifier	Identifier of data layers	string
dataLayer.type	Data type of data layers	enumeration: vector, coverage, …​

Example 4 — CSCSS Example showcasing selectors depending on layer identifiers and data type using system identifiers

 

[dataLayer.type = vector]
{
   // Display vector layers at 60% opacity by default
   opacity: 0.6;

   [dataLayer.identifier = 'Landuse']
   {
      // Except for Landuse that should show at 80% opacity
      opacity: 0.8;
   }

   // In CSCSS, the <layerid> syntax is equivalent
   // to [dataLayer.identifier = '<layerid>']
   Roads
   {
      opacity = 1.0; // and roads at 100% opacity
   }
}

Requirement 10
Identifier	/req/core/expressions-system-identifiers
A	An Encoding SHALL support …​
B	A Renderer SHALL support …​

Requirement 11
Identifier	/req/core/scale
A	An Encoding SHALL support …​
B	A Renderer SHALL support …​

Requirement 12
Identifier	/req/core/time
A	An Encoding SHALL support …​
B	A Renderer SHALL support …​

Requirement 13
Identifier	/req/core/layers
A	An Encoding SHALL support …​
B	A Renderer SHALL support …​

8.6.3.  Literal Expressions

Figure 5 — Literal Classes UML Diagram

A literal expression is an expression that has a fixed value in the encoding of the style. A similar literal class concept was originally defined in the OGC Filter Encoding 2.0 standard section 7.5.1.

The following types of literals are defined:

8.6.4.  Operation Expressions

An Operation Expression performs an operation specified by an Operator on one, two or three operand expressions, depending on whether they unary, binary or ternary operators. This core requirements class defines only Logical and Relational operators. Implementations are also required to support prioritizing operations (typically encoded using parentheses: ( )). Other requirements classes introduce support for additional operators for arithmetic, text and bitwise operations. Without support for the Any right-hand operand requirements class, the right-hand operands of RelationExpressions are limited to LiteralExpressions.

Table 15 — OperationExpression class

Figure 6 — Core Logic and Relational Operators UML Diagram

This requirements class defines the following Logical Operators :

Table 16 — Logical Operators

This requirements class defines the following Relational Operators:

Table 17 — Relational Operators

Example — CSCSS Example showcasing the use of logical and relational operators in a selector

Roads
{
   visibility: false;

   // Roads will be visible between scales 1:20,000 and 1:200,000
   [viz.sd > 20000 and viz.sd < 200000]
   {
      visibility: true;
   }
}

8.6.5.  Array Expressions

An array expressions defines zero, one, or more element expressions forming an ordered set.

CSCSS example: (123.0, viz.sd).

An array literal is a special type of array expression whose elements are all literals.

8.6.6.  Instance Expressions

An instance expressions instantiates an object of a class while optionally specifying values for member components. The default values for any member if not explicitly overridden can is specified by the class member definitions.

CSCSS examples:

An instance literal is a special type of instance expression assigning only literal expressions to its member components.

A Symbolizer may either set an object property with a complete new instance, or specifically override a particular member of that object property. This capability is particularly useful when using nested StylingRules, where a nested rule can inherit the Symbolizer from the parent StylingRule.

Example — CSCSS Example showcasing the use of logical and relational operators in a selector

Roads
{
   // Default to a gray stroke (completely replace stroke property)
   stroke: { gray };
   // For scales closer than 1:200,000 ...
   [viz.sd < 200000]
   {
      stroke.width: 5px; // inherit gray color, but modify the width to be 5 pixels.

      // For scales closer than 1:10,000, replace the stroke completely with a 5 meters blue stroke
      [viz.sd < 10000] { stroke: { blue, width: 5m } }
   }
}

9.1.1.  Symbolizer extension for vector features

Figure 7 — Basic Vector Features Extended Symbolizer Class UML Diagram

The following three new Symbolizer properties are defined by this requirements class:

Table 23 — Symbolizer class (vector features extension)

9.1.2.  Extended Identifiers for vector features

This requirements class defines as valid identifiers all of the accessible properties for a feature being portrayed with the name of those properties being the text of the identifier. Those identifiers are to be resolved with the value of that property. An encoding must support an escaping mechanism in cases where the name of a feature property might clash with a syntactic element.

9.1.2.1.  Extended System Identifiers

 

Figure 8 — Vector Features System Identifiers UML Class Diagram

In addition, the following new System Identifiers are defined by this requirements class:

Table 24 — System identifiers for vector features

Name	Definition	Data type and value
feature.identifier	Identifier of a particular feature	string or number
feature.geometryDimension	Dimension of geometry for a particular feature	0 (points), 1 (lines), 2 (polygons), 3 (polyhedrons)
feature.pass	Current rendering pass for the same feature	int
dataLayer.featuresGeometryDimension	Dimension of feature geometry (if same for all features)	0 (points), 1 (lines), 2 (polygons), 3 (polyhedrons), null (mixed)

9.1.2.1.1.  Feature Rendering Passes

This requirements class adds support for rendering vector geometry or coverage cells with multiple times with different symbolizer properties, as well as for re-ordering the rendering order so that either a single feature or an entire data layer is rendered after previous rendering passes have been completed.

See also the visualization pass defined in Core requirements class, which allows to render all data layers entire map with different symbolizers.

9.1.3.  Colors

Figure 9 — RGB Color class UML Diagram

Table 25 — RGB Color class

9.1.4.  Fills

Figure 10 — UML Class Diagram of the Symbology Fill

A Fill defines the graphical symbolizing parameters required to draw the filling of a two-dimensional shape such as a polygon. Separate conformance classes can extend this Fill class with additional properties.

Table 26 — Fill class

9.1.5.  Strokes

Figure 11 — Stroke Class UML Diagram

A Stroke defines the graphical symbolizing parameters for drawing an outline (e.g., for linear geometries or the exterior of a polygon geometry). As an abstract class and part of the base of the core graphical concepts, StrokeClass is a global point of extension to specify concrete ways to draw outlines. The StrokeClass properties are documented in the following table. By default the end of open subpaths are butt caped and at the corners of paths are miter joined when they are stroked.

A Stroke object inherits from a base StrokeStyling class, which is re-used in a separate requirements class for defining more complex strokes:

Table 27 — StrokeStyling class

9.1.5.1.  Graphical Units of Measure

 

Figure 12 — Graphical Units Enumeration UML Diagram

For styling parameters that define sizing and positioning of graphical objects (width, displacement, etc.), a specific unit of measure needs to be provided for the rendering engine. Therefore, properties where a unit of measure is relevant can be qualified with a particular uom codes.

Below is the list of allowed units of measure as per UCUM (except for pixel):

• portrayal units: pixel, millimeter, inch, percentage; and

• ground units: meter, foot.

The portrayal unit “pixel” is the default unit of measure. If available, the pixel size depends on the viewer client resolution, otherwise it is equal to 0.28mm x 0.28mm (~ 90 DPI).

9.1.6.  Markers

Figure 13 — Marker Class UML Diagram

A Marker inherits from a MultiGraphic which can contain multiple graphical elements:

Table 28 — MultiGraphic class

Without support for the Multi Graphics and Transforms requirements class, a MultiGraphic cannot contain another MultiGraphic.

A MultiGraphic itself inherits from a Graphic allowing to specify an opacity and a 2D position:

Table 29 — Graphic class

Table 30 — UnitPoint class

9.1.6.1.  Dot Graphics

 

Figure 14 — Dot Class UML Diagram

A round Dot is one type of Graphic defined by this requirements class that can be used as part of a Marker.

A Dot inherits from a Shape class allowing to define a stroke which controls the color and size of the dot (with the stroke’s width property).

Table 31 — Shape

Name	Definition	Type	Multiplicity
stroke	Stroke with which to render the shape outline	Stroke	0..1

9.1.6.2.  Image Graphics

 

Figure 15 — Image Class UML Diagram

An Image is one type of graphic defined by this requirements class that can be used as part of a Marker.

Table 32 — Image

Name	Definition	Type	Multiplicity
image	The image to use	Resource	1
hotSpot	0,0 position in the image	UnitPoint (uom-qualified)	1
tint	Tint (multiplying white)	Color	1
blackTint	Black tint (used for black	Color	1
alphaThreshold	Alpha value considered pickable	float	1

The actual image content is defined by a Resource, which can be specified by one or multiple properties:

Table 33 — Resource class

Name	Definition	Type	Multiplicity
url	URL for online resource	string	0..1
path	(preferably relative) path to local file	string	0..1
id	ID within a database table or a sprite	string	0..1
type	Selected media type for the resource	string	0..1
ext	File extension to build paths/URL with id	string	0..1
sprite	Name of source sprite file	string	0..1

9.1.6.3.  Text Graphics

 

Figure 16 — Text Class UML Diagram

A Text is one type of Graphic defined by this requirements class that can be used as part of a Marker.

Table 34 — Text

Name	Definition	Data type and value	Multiplicity
text	The character string for the text	string (unicode)1	1
font	The font to use for the text	Font	0..1
alignment	The alignment to use for the text	TextAlignment	0..1
1 This requirements class requires support for identifier parameter value expression for the text property without any additional requirements class. This allows to display the value of feature properties with a Text Marker.

Table 35 — TextAlignment

Name	Definition	Data type and value	Multiplicity
horzAlignment	Horizontal alignment	HAlignment	0..1
vertAlignment	Vertical alignment	VAlignment	0..1

Table 36 — HAlignment enumeration

Name	Definition
left	Left alignment
center	Center alignment
right	Right alignment

Table 37 — VAlignment enumeration

Name	Definition
top	Top alignment
middle	Middle alignment
bottom	Bottom alignment

The font property of a Text Graphic is defined uses the following Font class:

Table 38 — Font class

Name	Definition	Data type and value	Multiplicity
face	Face name	string	0..1
size	Size of the font (pt)	float	0..1
bold	Use bold style	bool	0..1
italic	Use italic style	bool	0..1

9.2.1.  Basic Vector Features Styling

10.1.1.  Overview

This requirements class adds support for defining how to portray coverage data by mapping values from the range (e.g., individual imagery bands) to color channels or to a single channel, as well as providing an option to apply a color and/or opacity map based on the values.

Figure 17 — Basic Coverage Symbolizer Class UML Diagram

10.1.2.  Requirements

10.2.1.  Overview

Figure 18 — HillShading Symbolizer Class UML Diagram

This requirements classand adds the capability to portray elevation coverages with a hill shading style. It depends on the Basic Coverage Styling requirements class.

10.2.2.  Requirements

11.1.1.  Overview

Figure 19 — Label Class UML Diagram

This requirements class adds support for labels that are placed using a placement algorithm (and may not always be placed) drawn as a separate pass on top of styled vector features and coverages. Like Markers, Labels inherit from the MultiGraphic class and may contain multiple graphical elements.

Table 46 — Extended Symbolizer Class

11.1.2.  Requirements

11.1.3.  Basic Labeling

11.2.1.  Overview

Figure 20 — Font outlines UML Diagram

This requirements class adds support for Text font outlines to improve readability on any background.

11.2.2.  Requirements

11.2.3.  Font Outlines

12.1.1.  Overview

This requirements class adds capabilities for strokes with the possibility to define:

12.1.2.  Requirements

12.1.3.  Dashes

Implementations shall support all properties in the below table for style encodings and renderers.

Figure 21 — Dashed strokes class UML diagram

Table 49 — Extended Stroke class for dashes

12.1.3.1.  Dash Pattern

Requirement 50
Identifier	http://www.opengis.net/spec/cartosym-1/2.0/req/dashPattern
Prerequisite	Requirements class 7: http://www.opengis.net/spec/cartosym-1/2.0/req/dashes
A	An Encoding SHALL support defining a dashPattern property for the stroke symbolizer.
B	A Renderer SHALL support dashing vector geometry based on a dashPattern property.
Statement	Figure 22 — In black stroke without dashes, in red with a dash pattern alternating a long dash with a short gap.

12.1.3.2.  Dash Offset

Requirement 51
Identifier	http://www.opengis.net/spec/cartosym-1/2.0/req/dashOffset
Prerequisite	Requirements class 7: http://www.opengis.net/spec/cartosym-1/2.0/req/dashes
A	An Encoding SHALL support defining a dashOffset property for the stroke symbolizer.
B	A Renderer SHALL support dashing vector geometry based on a dashOffset property.
Statement	Figure 23 — In black stroke without dashes, in red with a dash pattern preceded by an offset on the rendering of the associated dash pattern.

12.2.1.  Overview

Figure 24 — Casing and centerline strokes class UML diagram

This requirements class adds support for Strokes with a casing and centerline.

Table 50 — Extended Stroke class

12.2.2.  Requirements

12.2.3.  Casing and Centerline

13.1.1.  Overview

This requirements class adds capabilities for defining hatch fills as a pattern of lines controlled by:

Figure 25 — Hatches Fills UML Diagram

13.1.2.  Requirements

13.1.2.1.  Hatch fills

Requirement 54
Identifier	/req/hatch-fills
A	Encodings and Renderers SHALL support a hatch property within the Fill class, defined as a Hatch class.

Table 51 — Fill class extended for hatches

Name	Definition	Type	Multiplicity
hatch	Line-based hatch fill	Hatch	0..1

Table 52 — Hatch class

Name	Definition	Data type and value	Multiplicity
width	Thickness of hatch	float	0..1
angle	Hatches orientation clockwise degree	float	0..1
distance	Distance between two consecutive hatches	float	0..1

 

Figure 26 — Input shape to be hatched

 

Figure 27 — Default hatch properties (width : 1 px, angle : 45 °, distance : 10 px)

13.1.2.2.  Width

Requirement 55
Identifier	/req/hatch-width
A	An Encoding SHALL support defining a width property for the hatch fill symbolizer.
B	A Renderer SHALL support fill hatching vector geometry based on a width property.

 

Figure 28 — A hatch lines with a width of 5px

13.1.2.3.  Angle

Requirement 56
Identifier	/req/hatch-angle
A	An Encoding SHALL support defining an angle property for the hatch fill symbolizer.
B	A Renderer SHALL support fill hatching vector geometry based on an angle property.

 

Figure 29 — A hatch lines with an angle of 0 degree

13.1.2.4.  Distance

Requirement 57
Identifier	/req/hatch-distance
A	An Encoding SHALL support defining a distance property for the hatch fill symbolizer.
B	A Renderer SHALL support fill hatching vector geometry based on a distance property.

 

Figure 30 — A hatch lines with a distance of 5px

13.2.1.  Overview

Figure 31 — Dotpattern Fills UML Diagram

This requirements class extends Fill capabilities by adding support for dot fills with a point-based pattern.

Table 53 — Fill class extended for dot patterns

Table 54 — Dotpattern class

Table 55 — Distance class

13.2.2.  Requirements

13.3.1.  Overview

This requirements class adds support for stipple fills. A stipple fill is a pattern of dots defined by a ratio property.

Figure 32 — Stipple Fills UML Diagram

13.3.2.  Requirements

13.3.2.1.  Stipple fills

Implementations shall support all properties in the below table for style encodings and renderers.

Table 56 — Fill class extended for stippling

Name	Definition	Type	Multiplicity
stipplingRatio	Ratio of stippling dots according to area filled	float (betwwen 0 an 1)	0..1

Requirement 58
Identifier	/req/stippling-ratio
A	An Encoding SHALL support defining a ratio property for the stipple fill symbolizer.
B	A Renderer SHALL support stipple fill vector geometry based on a ratio property.

 

Figure 33 — Fill a shape area with dots defined by a ratio (0.2, 0.5, 0.8)

14.1.1.  Overview

This requirements class adds support for using ParameterValues i.e., arbitrary Expressions (not only literals), for all Symbolizer properties.

14.1.2.  Requirements

14.2.1.  Overview

This requirements class removes the restriction that right-hand side operands of RelationExpressions are limited to LiteralExpressions. For expressions encoded using CQL2, it is analogous to the CQL2 Property-Property comparison requirements class.

14.2.2.  Requirements

14.2.3.  Any right-hand operands

14.3.1.  Overview

14.3.2.  Conditional expressions

Figure 34 — Conditional Expressions UML Class Diagram

Table 57 — ConditionalExpression class

14.3.3.  Requirements

14.3.4.  Conditional Expressions

14.4.1.  Overview

Figure 35 — Variable Expressions UML Class Diagram

This requirements class adds support for defining variables that can be used to facilitate re-use of definitions in encodings, as well as to provide configurable elements that can be associated with application control such as a slider or drop-down control.

14.4.2.  Requirements

14.4.3.  Variables

15.1.1.  Overview

This requirements class adds support for arithmetic operations.

Figure 36 — Arithmetic Operators UML Diagram

Table 59 — arithmetic

15.1.2.  Requirements

15.1.3.  Arithmetic Operators

15.2.1.  Overview

Figure 37 — TextRelation Operators UML Diagram

This requirements class adds more advanced support for evaluating the relation between text values, including the like operator, starts with, contains, ends with, as well as not variants for all these.

Table 60 — comparison

15.2.2.  Requirements

15.2.3.  Text Relation Operators

16.1.1.  Overview

This requirements class adds support for function call expressions.

16.1.1.1.  Function call expressions

 

Figure 38 — Functions UML Class Diagram

Table 61 — FunctionCallExpression class

Name	Type	Definition	multiplicity
function	Function	Function to be called	1
arguments	Expression	Arguments to the function	0..*

Table 62 — Function class

Name	Type	Definition	multiplicity
name	string	Name	1
parameters	map < string, type >	Parameters	1
returnType	type	Return type	1

16.1.2.  Requirements

16.1.3.  Functions

16.2.1.  Overview

Figure 39 — Math Functions UML Diagram

16.2.2.  Requirements

16.2.3.  Functions

Example — Math Functions

16.3.1.  Overview

Figure 40 — Array Relation Functions UML Diagram

Table 64 — Array relation functions

16.3.2.  Requirements

16.3.3.  Array Relation Functions

16.4.1.  Overview

Figure 41 — Text Manipulation Functions UML Diagram

Table 65 — Text manipulation functions

16.4.2.  Requirements

16.4.3.  Text Manipulation Functions

17.1.1.  Example

The following example demonstrates the CartoSym JSON encoding for the same example Basic Vector Styling for polygons equivalent to the one seen in the following CartoSym CSS section (Example 1 in 21.1.8.1. Basic Vector Styling).

{
   "metadata":
   {
      "title": "Styling polygon vector features",
      "abstract": "Basic vector features styling (polygons)"
   },
   "stylingRules": [
      {
         "selector":
         {
            "op": "and",
            "args": [
               { "op": "=", "args": [ { "sysId": "dataLayer.id" }, "Landuse" ] },
               { "op": "=", "args": [ { "sysId": "dataLayer.type" }, "vector" ] },
               { "op": "=", "args": [ { "sysId": "dataLayer.featuresGeometryDimensions" }, 2 ] }
            ]
         },
         "symbolizer":
         {
            "$comment": "Do not show Landuse layer by default",
            "visibility": false
         },
         "nestedRules": [
            {
               "$comment": "Show land use if zoomed in more than 1:200,000 for data valid within visualization's selected time range",
               "selector":
               {
                  "op": "and",
                  "args": [
                     { "op": "<", "args": [ { "sysId": "vis.id" }, 200000 ] },
                     { "op": ">=", "args": [ { "property": "validDate" }, { "sysId": "vis.timeInterval.start.date" } ] },
                     { "op": "<=", "args": [ { "property": "validDate" }, { "sysId": "vis.timeInterval.end.date" } ] }
                  ]
               },
               "symbolizer":
               {
                  "visibility": true,
                  "opacity": 0.8,
                  "zOrder": 1,
                  "fill": { "color": "gray", "opacity": 0.5 },
                  "stroke": { "color": "gray", "width": { "px": 2.0 }, "opacity": 1.0 }
               },
               "nestedRules": [
                  {
                     "$comment": "Select different fill and stroke color based on FunctionCode property",
                     "selector": { "op": "=", "args": [ { "property": "FuntionCode" }, "parking" ] },
                     "symbolizer":
                     {
                        "fill": { "alter": true, "color": "darkGray" },
                        "stroke": { "alter": true, "color": [ 32, 32, 32 ] }
                     }
                  },
                  {
                     "selector": { "op": "=", "args": [ { "property": "FuntionCode" }, "park" ] },
                     "symbolizer":
                     {
                        "fill": { "alter": true, "color": "darkGreen" },
                        "stroke": { "alter": true, "color": "green" }
                     }
                  },
                  {
                     "selector": { "op": "=", "args": [ { "property": "FuntionCode" }, "commercial" ] },
                     "symbolizer":
                     {
                        "fill": { "alter": true, "color": "lightGray" },
                        "stroke": { "alter": true, "color": "lightGray" }
                     }
                  },
                  {
                     "$comment": "If zoomed in more than 1:10,000",
                     "selector": { "op": "<", "args": [ { "sysId": "vis.sd" }, 10000 ] },
                     "symbolizer":
                     {
                        "$comment": "Change stroke width to 4 pixels and add a text marker (positioned at centroid + horizontal offset) showing FunctionTitle property",
                        "stroke": { "alter": true, "width": { "px": 4.0 } },
                        "marker": {
                           "elements": [
                              {
                                 "type": "Text",
                                 "position": [20, 0],
                                 "$comment": "Offset 20 pixels to the right",
                                 "text": { "property": "FunctionTitle" },
                                 "alignment": [ "left", "top" ],
                                 "font": {
                                    "face": "Arial",
                                    "size": 14,
                                    "bold": true,
                                    "italic": true,
                                    "opacity": 1.0,
                                    "color": [ 0, 0, 0 ]
                                 }
                              }
                           ]
                        }
                     },
                     "nestedRules": [
                        {
                           "$comment": "Add icons at centroid based on land use function code property",
                           "selector": { "op": "=", "args": [ { "property": "FuntionCode" }, "parking" ] },
                           "symbolizer":
                           {
                              "marker": {
                                 "alter": true,
                                 "elements":
                                 {
                                    "index": 1,
                                    "value": {
                                       "type": "Image",
                                       "image": {
                                          "uri": "http://example.com/parkingIcon",
                                          "path": "parkingIcon.png",
                                          "id": "parking",
                                          "type": "image/png",
                                          "ext": "png"
                                       },
                                       "hotSpot": [ { "pc": 50 }, { "pc": 50 } ],
                                       "tint": "white",
                                       "blackTint": "blue",
                                       "alphaThreshold": 0.1
                                    }
                                 }
                              }
                           }
                        },
                        {
                           "$comment": "Add icons at centroid based on land use function code property",
                           "selector": { "op": "=", "args": [ { "property": "FuntionCode" }, "park" ] },
                           "symbolizer":
                           {
                              "marker": {
                                 "alter": true,
                                 "elements": {
                                    "index": 1,
                                    "value": {
                                       "type": "Image",
                                       "image": {
                                          "uri": "http://example.com/park",
                                          "path": "park.png",
                                          "id": "park",
                                          "type": "image/png",
                                          "ext": "png"
                                       },
                                       "hotSpot": [ { "pc": 50 }, { "pc": 50 } ],
                                       "tint": "white",
                                       "blackTint": "blue",
                                       "alphaThreshold": 0.1
                                    }
                                 }
                              }
                           }
                        },
                        {
                           "$comment": "Add icons at centroid based on land use function code property",
                           "selector": { "op": "=", "args": [ { "property": "FuntionCode" }, "commercial" ] },
                           "symbolizer":
                           {
                              "marker": {
                                 "alter": true,
                                 "elements": {
                                    "index": 1,
                                    "value": {
                                       "type": "Image",
                                       "image": {
                                          "uri": "http://example.com/commercial",
                                          "path": "commercial.png",
                                          "id": "commercial",
                                          "type": "image/png",
                                          "ext": "png"
                                       },
                                       "hotSpot": [ { "pc": 50 }, { "pc": 50 } ],
                                       "tint": "white",
                                       "blackTint": "blue",
                                       "alphaThreshold": 0.1
                                    }
                                 }
                              }
                           }
                        }
                     ]
                  }
               ]
            }
         ]
      }
   ]
}